One aspect of the efficient management of middleware like Web servers, application servers, and enterprise portal servers in a client-server infrastructure is workload management. In the best case, servers are neither idle nor working to full capacity. A reasonable goal might be to keep the workload close to the maximum capacity with a buffer for potential spikes.
In recent years a shift with respect to application programming has taken place. While middleware still processes server-side applications and delivers the results in response to client requests, an increasing number of application logic has started moving to the client. Servers merely deliver such applications as source or script code to the client, which takes care of the execution. At runtime the client-side applications continue to request resources from the server. It is common practice for them to distinguish between two main request types, namely synchronous and asynchronous requests.
Synchronous requests to the server are used whenever the application cannot proceed without the requested data, whereas asynchronous requests can be used to start long running server-side tasks that remain transparent to the user. They also come into play when the response from the server can be injected into the application dynamically no matter when it is received. In any case, the user should be able to continue working with the application while the server-side processing is done in the background without blocking the application flow.
At present, the paradigm shift in regards to client-server applications is unused for managing the workload of middleware products. Synchronous and asynchronous requests are handled by servers in the same way even when they reach their capacity limits. The client-side part of Web applications cannot influence the priority of a request sent to the server, although, the Web application knows best about the semantics and the corresponding importance of the data and resources it requests.